Systems and methods for building and deploying mobile applications

ABSTRACT

Systems and methods may generate applications for operating platforms. A data source for an application definition may be created, and an object may be mapped to the data source. An application definition may be generated from the data source and object. An operating platform for application publication may be selected from among a plurality of platforms. An application may be generated for the selected operating platform.

CROSS REFERENCE TO RELATED APPLICATION

This application is a Continuation of U.S. application Ser. No.13/767,433 filed Feb. 14, 2013. U.S. application Ser. No. 13/767,433claims priority from U.S. Provisional Application No. 61/618,157,entitled “System and Method for Building and Deploying Web-Based MobileApplications Across Multiple Mobile Platforms From a Single ApplicationDefinition,” filed Mar. 30, 2012. The entirety of both of theabove-listed Applications are incorporated herein by reference.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is an example flow chart of a mobile application creation anddeployment process according to an embodiment of the invention.

FIG. 2 is an example flow chart of a process for editing a definition ofa mobile application according to an embodiment of the invention.

FIG. 3 is an example illustration of architectural components accordingto an embodiment of the invention.

FIG. 4 is an example hierarchy of user interface pages and componentsthat define a mobile application according to an embodiment of theinvention.

FIG. 5. is an example block diagram of data sources, objects, userinterface (UI) components, and extensions that comprise an applicationdefinition according to an embodiment of the invention.

FIG. 6. is an example of a set of extensions and application definitionsaccording to an embodiment of the invention.

FIG. 7. is an example of components and flow involved during a previewor publishing operation of a mobile application according to anembodiment of the invention.

FIG. 8. is an example of infrastructure components and networkcommunication paths according to an embodiment of the invention.

DETAILED DESCRIPTION OF SEVERAL EMBODIMENTS

A mobile application development platform may enable mobile applicationdevelopment by using an interface, for example a web browser-basedinterface, to assemble and generate applications that may run onmultiple mobile operating systems and/or mobile web browsers, from asingle application definition which may include mappings between userinterface pages and components, objects, extensions, and/or datasources. One example of a mobile application that can be developed bythe platform is an application that displays projects and theircorresponding tasks and team members. The platform can be used to definethe data sources, such as a database or a non-mobile third-partyapplication, from which the project management app may read and writedata. The platform can be used to define the objects and relationshipswith the application, such as projects, tasks, and team members, wheretasks and team members objects can belong to a project object. Finally,the platform can be used to specify how the user interface shoulddisplay the objects and enable users to interact with the object data.The platform can be used to generate the project management applicationfor multiple mobile operating systems. For example, the platform cangenerate source code that is designed to run on Apple iOS devices. Inthis case, the source code may include an Apple XCode project andcorresponding libraries, using a language called Objective-C. This iOSmobile app may be compiled and can be installed and executed onsupported iOS devices. The same project management application can begenerated to run as a mobile web application running in mobile webbrowsers. In this case, the platform may also generate source code andcorresponding libraries in Javascript, Cascading Style Sheets (CSS), andHTML. This mobile web application can be hosted on a web server and maybe accessed via any mobile device via a browser. Other examples andoptions may be possible, some of which are described in greater detailbelow.

Systems and methods described herein may enable application designers topreview an application by downloading automatically generated files foruse within a web browser and/or on a mobile device. In some embodimentsthis may be done without manual software compilation steps orinstallation of mobile operating system-specific software developmentkits on the application designer's computing device.

Systems and methods described herein may enable developers to add orchange functionality of a mobile application by invoking external customweb services, stored procedures, and/or by installing extensions withinan application. When installed, these extensions may automaticallycreate additional application definition items such as user interfacepages and components, objects, extensions, and/or data sources.

Systems and methods described herein may generate a run-time serverapplication that may communicate with a client-side mobile applicationto provide supporting functions such as data storage, data integrationwith source systems, and/or business logic extensions. This run-timeserver application may be automatically installed on web serversprovided by a third party, or may be saved to a third party source coderepository from which authorized users can download and install therun-time server application on their own server infrastructure.

The platform may generate run-time source code components that maycomprise a fully functional mobile application. For example, theplatform may generate: (1) backend server code and programminginterfaces, (2) client-side library (SDK) code for accessing the backendserver interfaces, and (3) client-side user interface (UI) code.Specifically, in various embodiments, the backend server component maysupport Ruby on Rails and/or Java Play language frameworks, the SDKcomponent may support Backbone.js, Sencha Touch, iOS, and/or Androidlanguage frameworks, and/or the client-side UI component may supportjQuery Mobile, iOS, and/or android language frameworks. The client-sideSDK code may also include automatically generated documentation that mayprovide detailed specifications of the available function calls andparameters.

Devices operating the various applications and performing the variousprocesses described herein may comprise one or more computers. Computersmay be linked to one another via a network or networks. A computer maybe any programmable machine capable of performing arithmetic and/orlogical operations. In some embodiments, computers may compriseprocessors, memories, data storage devices, and/or other commonly knownor novel components. These components may be connected physically orthrough network or wireless links. Computers may also comprise softwarewhich may direct the operations of the aforementioned components.Computers may be referred to with terms that are commonly used by thoseof ordinary skill in the relevant arts, such as servers, PCs, mobiledevices, and other terms. It will be understood by those of ordinaryskill that those terms used herein are interchangeable, and any computercapable of performing the described functions may be used. For example,though the term “server” may appear in the following specification, thedisclosed embodiments are not limited to servers. A network may be anyplurality of completely or partially interconnected computers whereinsome or all of the computers are able to communicate with one another.It will be understood by those of ordinary skill that connectionsbetween computers may be wired in some cases (i.e. via Ethernet,coaxial, optical, or other wired connection) or may be wireless (i.e.via WiFi, WiMax, or other wireless connection). Connections betweencomputers may use any protocols, including connection oriented protocolssuch as TCP or connectionless protocols such as UDP. Any connectionthrough which at least two computers may exchange data can be the basisof a network.

Referring to FIG. 1, a platform may provide systems and/or enablemethods for building and deploying mobile applications across one ormore mobile operating systems. Users may log in to an applicationdesigner 100, which may also be referred to as a developmentenvironment, via a web browser with Internet connectivity and/or viasome other user interface. If a new mobile application is being created,the user may enter a name for the application 102, and may optionallyselect a template 104 with pre-assembled functionality. The platform mayprovide access to a plurality of mobile application templates that maybe used to reduce development time and/or complexity. Users may alsopublish new templates that may be made available for selection. In someembodiments, only authorized system administrators of the platformand/or other qualified users may be permitted to publish new templates.When a template is selected, the new application definition may bepopulated with data sources, objects, extensions, and/or user interfaceelement metadata with relationship mappings that may describe how anapplication should behave when running. For example, a template mayinclude a pre-defined mobile application for employees to perform commonhuman resources related tasks or requests such as view other employeesin a company directory, view news about the company, and/or viewpersonal compensation information. When this template is selected, anapplication may automatically be created and populated with a series ofobjects representing entities such as employees, news items, andcompensation. In addition, the template may automatically generate userinterface components mapped to these objects, such as a home page withnew items and tool bar buttons, a company directory list page, and atotal compensation list page with chart components. With the basicobject and user interface structure now in place, the user may continueto edit the application that was created from the template to ensure itmeets the specific requirements of the user's company. A generic exampleof metadata entities and mappings is shown in FIG. 5, and explained infurther detail below.

Referring again to FIG. 1, in addition to creating a new application,the user may be able to select an existing application 106 that waspreviously created. Once the user creates a new application or selectsan existing application, they may be presented with a graphicalinterface that may allow for visual editing of the applicationdefinition 110. As described in greater detail below, after a user hasedited the application definition 110, they may preview the application112. If the user is dissatisfied with the preview, the user may continueediting 110. If the user is satisfied with the preview, the user maypublish the application 114. After the application has been published,it may also be submitted to a relevant app store 116 (e.g., an Apple orGoogle store), based on whether the user desires to distribute the appvia a public app store. The published application may be submitted tothe relevant app store 116 if it is a native application designed to runspecifically on an OS associated with the relevant app store (e.g., iOSapp to the Apple store and/or Android app to the Google store), forexample. Published applications may also be distributed in other ways.For example, some applications, such as HTML5 mobile applications, maybe deployed to users via an Internet URL address and may not require athird party distribution channel. After the app has been published, theuser may want to update the app with new functionality, at which pointthey may restart the process described in FIG. 1. If updates includingnew functionality are made to native applications, the applications maybe re-compiled and re-distributed to end-users via the original channel.There may be end users who delay installing updates to the application,and older versions of server-side APIs may be maintained so thatprevious versions of native apps will continue to function.

Although the process for editing application definition metadata may benon-linear, the user may follow a predetermined process to create and/oredit the application definition, as described in further detail in FIG.2.

The process of creating and/or editing the application definition mayinclude creating data sources. Data sources may be locations from whichdata may be retrieved and/or to which data may be saved by a mobileapplication. Mobile applications designed for businesses may store andedit information that is contained in a third party application such asan enterprise resource planning (ERP) solution or a customerrelationship management (CRM) solution. Examples of data that may beedited or displayed within a typical business mobile application includecustomers, orders, invoices, and/or activities. In some cases, themobile application may store or edit data from multiple data sources. Asillustrated in FIG. 5, data sources 506 may be linked via storageconnectors 504 to databases, web services, and/or software applications502 such as, but not limited to, MySQL, Postgress, REST or SOAP webservices, Oracle e-Business Suite, SAP ERP, and/or Salesforce.com.Storage connectors 504 may be pre-built adapters which may connect to aspecific database, web service, and/or software application. Forexample, to create a data source 506 that is connected to an externalMySQL database, a user may employ a MySQL storage connector. Theplatform may also provide a storage connector 504 to a built-indatabase, which may be used to save or retrieve data without having toconnect to an external data source. Further, users may be able topublish such new storage connectors 504. In some embodiments, onlyauthorized system administrators of the platform and/or other qualifiedusers may be permitted to publish new storage connectors 504 for use inapplications. An application designer may specify connectivityparameters within the data source as may be required by the storageconnector 504, such as, but not limited to, network address, user name,and/or password. The parameters may be used to establish a connectionwhen a connection is requested and/or needed. As described in greaterdetail below, the data sources 506 may include and/or be associated withvarious objects 508, fields 510, events 512, extensions 514, custom orthird-party web services 516, UI components 518, and/or UIsub-components or properties 520. FIG. 5 further illustrates therelationships between the metadata entities and their children. Datasources 506 may contain fields or data elements which may be mapped tocorresponding fields 510 within an object 508. The object 508 mayinclude lifecycle events 512 based on operations such as create, update,save, and/or delete, which can invoke custom code 515 or extensions 514that may correspond to custom or third party web services. 516.Furthermore, objects 508 may be mapped to UI components 518 which mayexpose data within UI component properties 520 that may be mapped toobject fields 510.

Referring again to FIG. 2, editing an application definition may beginwith the creation of one or more data sources 200. Once data sources aresaved, objects may be created and mapped to the data sources 202. Asillustrated in the example in FIG. 5, objects 508 may contain fields 510that may be mapped to corresponding fields on the object's data source.Each object may be mapped to one data source, and each field within anobject may be mapped to a single field on a data source. An object maybe an abstract representation of a major data element from the datasource. For example, if the data source is a customer relationshipmanagement (CRM) system, and one of the data elements in the CRM systemis customer, an object called “customer” may be mapped to the CRM datasource's customer element. The mapping between an object and data sourcemay be one-to-one. An application may have multiple objects that may bemapped to different data sources. Optional query scopes may be definedat the object level. The query scopes may serve to retrieve a subset ofdata from the data source based on matching field value operationsand/or sort orders. Further, a query scope may apply additional rules tofilter the data based on the current end-user's attributes, such as, butnot limited to, country, language, and/or time zone. This query scopemay be referenced when defining user interface elements to enableend-users of a mobile application to interact with specific subsets ofdata.

An object may optionally be flagged as an authenticatable object withcorresponding fields identified that may determine how an individualuser of the application may be identified (for example, authenticationlookup fields, such as name or email ID), how the user may beauthenticated (for example, an authentication match field, such as apassword), and/or what role(s) may be assigned to the user (for example,an authorization role field). For example, the authentication object maybe mapped to a data source containing user information such as name,password, and/or roles. If at least one authenticatable object exists,then other objects may have authorization rules that may determine whichuser roles may have access to the object. One or more authorizationrules may be defined at the object level, and may specify whether therole can perform operations on specified object field data. Theseoperations may include, for example, reading, writing, creating,updating, and/or deleting data. If no authorization rules exist on anobject, which may be true by default in some examples, then all usersand roles may have access to perform any operation on the object.

An example of an object and fields representing employee data may be asfollows:

<object-definition> <application-definition-idtype=“integer”>1</application-definition-id><code-friendly-name>Employee</code-friendly-name><composite-key-delimiter>-</composite-key-delimiter> <created-attype=“datetime”>2012-11-17T23:49:26Z</created-at><default-sort-field>last_name</default-sort-field><default-sort-order>Ascending</default-sort-order><display-friendly-name>Employee</display-friendly-name><downcase-lookup-field type=“boolean”>true</downcase-lookup-field><has-secure-password type=“boolean”>false</has-secure-password> <idtype=“integer”>4</id> <lookup-field nil=“true”/><mapping>employees</mapping> <name>Employee</name> <role-fieldnil=“true”/> <slug>employee</slug> <storage-interface-idtype=“integer”>2</storage-interface-id> <updated-attype=“datetime”>2012-11-17T23:49:26Z</updated-at> </object-definition><field-definitions type=“array”> <field-definition> <autotype=“boolean”>true</auto> <created-attype=“datetime”>2012-11-17T23:49:26Z</created-at><display-friendly-name>Id</display-friendly-name><field-type>Integer</field-type> <file-type>Image</file-type> <file-urltype=“boolean”>false</file-url> <id type=“integer”>21</id> <keytype=“boolean”>true</key> <mapping>id</mapping> <name>id</name><object-definition-id type=“integer”>4</object-definition-id> <requiredtype=“boolean”>false</required> <slug>id</slug> <updated-attype=“datetime”>2012-11-17T23:49:26Z</updated-at> </field-definition><field-definition> <autotype=“boolean”>false</auto> <created-attype=“datetime”>2012-11-17T23:49:26Z</created-at><display-friendly-name>Department</display-friendly-name><field-type>String</field-type> <file-type>Image</file-type> <file-urltype=“boolean”>false</file-url> <id type=“integer”>28</id> <keytype=“boolean”>false</key> <mapping>department</mapping><name>department</name> <object-definition-idtype=“integer”>4</object-definition-id> <requiredtype=“boolean”>false</required> <slug>department</slug> <updated-attype=“datetime”>2012-11-17T23:49:26Z</updated-at> </field-definition>... </field-definitions>

In this example, the object metadata fields are as follows:

application-definition-id: a unique identifier for the application

code-friendly-name: the name of the object to be referred to in any code

composite-key-delimiter: character used to build composite keys

created-at: the date when the object for created

default-sort-field: the default field used to sort instances of theobject

default-sort-order: the default sort order of the object instances

display-friendly-name: the name of the object to be displayed in thedesigner

downcase-lookup-field: used when the object is intended for lookuppurposes

has-secure-password: used when the object is for authentication

id: unique identifier for the object

lookup: used when the object is intended for lookup purposes

mapping: name of data source component that the object is mapped to

name: human-readable name of the object

role-field: used for access control purposes

slug: the URL-friendly name of the object

storage-interface-id: the identifier of the data source that the objectis mapped to

updated-at: the date the object definition was last updated

And the field metadata fields are as follows:

field-definition: the start of each field definition and its properties

auto: whether the field is auto created

created-at: date the field was created

display-friendly-name: the name of the field to be displayed in thedesigner

field-type: the data type of the field (i.e. integer, boolean, string,etc.)

file-type: whether the field corresponds to a media file (i.e. picture,audio, etc.)

file-url: the location of the file if the field corresponds to a mediafile

id: unique identifier for the field

key: whether the field is part of the key for the object

mapping: the name of the data source element that the field maps to

name: the human-readable name of the field

object-definition-id: the unique identifier of the object that the fieldbelongs to

required: whether the field is required

Referring again to FIG. 2, once the user has defined data sources andobjects, optional extensions 210 may be installed to expand thefunctionality of the application. An example is an extension that sendsShort Message Services (SMS) text messages. Another example is anextension that sends push notifications to native applications viaApple's Push Notification service (APN) or Google's Cloud Messaging forAndroid (GCM). As illustrated in FIG. 6, extensions 602 may be developedby different parties and may be registered by a user, such as anauthorized system administrator, within the platform to become availablefor use by application designers. For example, extensions may beprovided by a platform administrator 604 and/or by a third party 606.The application designer may be able to install one or more extensionswithin one or more applications 608, 610. When an extension is installedwithin an application, it may automatically insert application metadatathat may include one or more data sources, objects, extension code,and/or user interface elements.

Referring again to FIG. 2, the user may map the extension-generatedmetadata 214 to other data sources, objects, and/or custom code withinthe application definition. Further, the extension may exposeconfiguration settings 212 that the user may edit from within thedesigner user interface. These settings may be extension-specific, andmay vary based on the selected extension and any supporting third partyservices. For example, settings for a push notification extension mayinclude the certificates required by Apple or Google to utilize theirmessaging delivery services. As illustrated in FIG. 8, extensionsdeveloped by a network and/or system operator 810 may be executed onnetwork and/or system operator managed servers 814, and may interactwith web-based third party services 812. Extensions may also bedeveloped and hosted by customers or partners of the operator, withintheir own managed infrastructure 824, which may also interact withweb-based third party services 812.

If a user desires further customization of business logic related toextensions or in response to an object event, they may choose to developcustom code at the object model or controller level or invoke a customweb service that was developed outside the platform 220. The web servicemay be built in any programming language that is able to produce webservices based on the Representational State Transfer (REST) model.Custom code may be written within the object's lifecycle events at thecontroller (before and after requests) and model level using functionssuch as create update, save, and/or delete. Authoring custom code inthis manner may be useful, for example, for implementing customvalidation, business logic, pre and post processing requests, defaultvalues, and/or invoking extensions. To invoke a custom web service fromthe application, the user may install a generic web service extension orauthor custom code that invokes the web service using RESTful protocol,for example. FIG. 5 illustrates an example mapping between object events512, extensions 514, custom code 515, and the corresponding custom orthird party web service 516. An example use of a custom web servicecould be to update an external system when a user creates a new objectinstance in a preexisting application. An example use of a third-partyservice could be to update usage information in a third-party analyticssolution in response to user operations within a preexistingapplication.

Referring again to FIG. 2, the platform may allow a user to assemble theuser interface of the application by using page and component elements226. These user interface components may be visual elements of theapplication such a list of records with a search button, a form withdata entry fields and a submit button, and/or an interactive map of theuser's current location. The platform may internally store the userinterface (UI) elements, including pages and components, in ahierarchical structure. In the hierarchical structure, the relationshipof a UI element to its parent and children, and the attribute values (orproperties) of the element, may determine how the UI element will berendered when the app is running in the client device environment. UIcomponent properties may vary based on the type of component. Forexample, a button component may have properties that control appearancesuch as name, width, border radius, background color, and/or font style.A list page component may have properties that determine what data todisplay, such as object query scope, row header, row body, and/or itemsper page. FIG. 5 illustrates an example mapping between objects 508 andUI components 518, and between object fields 510 and componentproperties 520.

An example hierarchy of UI elements is illustrated in FIG. 4. A contentpage 400 may contain a list component 402 and a button component 404. Inthis example, the list component 402 may render a list of data recordsbased on the object to which the component is mapped. Each record in thelist may be displayed according to the list item component 408, which inthis example is an image component 410 followed by a label component412. The button component 404 may enable the end-user to create a newrecord, and may display a new record form page 406 to allow for input ofthe new record data. The detail page 414 may display data from anindividual record that the end-user may select in the list component402. The record data may be displayed on the detail page using an imagecomponent 416 and one or more styled text components 420. For example,an employee services application may contain a list page called“employee directory” that may be mapped to the employee object's “all”query scope to display all records. The row header property of the listpage may display the employee object fields first name and last name.The row body property may display the employee object field title anddepartment. This may result in a list page in a mobile application thatdisplays all employees in a list, with the employee first name, lastname, title, and department in each row of the list.

Referring to FIG. 1 and FIG. 2, before previewing 112 or publishing 114the application, the platform may allow a user to specify generalapplication settings 230 such as, but not limited to, which mobileoperating systems may be supported and/or general appearance propertiessuch as color theme and/or icon. If the application is to be generatedas a native mobile application, then additional settings 232, such as,but not limited to, ad-hoc provisioning files, private keys, and/ordeveloper certificates, may be specified or uploaded to enable theapplication to be compiled as a native application on selected mobileoperating systems.

Referring again to FIG. 1, the platform may allow a user to preview theapplication 112 based on the current application metadata definitions.Previews may be available for any mobile operating systems that theapplication may be targeted to support as specified in its generalapplication settings. As illustrated in FIG. 7, the application designermay, for example, click a preview button within a designer userinterface 702, which may be a browser-based interface. The user may beable to select from a list of supported mobile operating systems basedon the application settings 706, and a selection may initiate a previewprocess based on the current application metadata definition 704. Theplatform may include multiple generators 710 that may read theapplication definition metadata 704 and may automatically create acorresponding mobile application for each supported and/or selectedmobile operating system and platform. The generators may be pre-builtcomponents of the platform, and may be developed to meet specificrequirements of the target mobile platform. Each generator may readapplication metadata and generate a software development kit (SDK) for aspecific mobile platform and a user-interface (UI) for a specific mobileplatform. Collectively, the combination of the SDK and UI may bereferred to as a generated application. It is possible to also generateonly an SDK and develop the UI outside the platform that utilizes theSDK. Furthermore, the platform may be architected to support theaddition of newly developed generators as new mobile platforms, such asMicrosoft Windows Mobile 8, emerge and become ready to support. Theillustration in FIG. 7 depicts three example generators. For example,generators may be provided for mobile platforms such as, but not limitedto, HTML5 web applications, Android native applications, and/or iOSnative applications. In one example, the generator for HTML5 web appsmay copy the assembled output HTML, javascript, and cascading stylesheet (CSS) files 718 to a web-based file server 716. The applicationdesigner may then preview the HTML5 web application 724 within a webbrowser. The generators that create native applications may establishconnectivity with web-based application compilers such as, but notlimited to, a Unix-based server for native Android compilation 714and/or an OSX server for native iOS compilation 712. Once thecompilation servers have completed their tasks, the compiled nativeapplication files 717 may be copied to a web-based file server 716. Theapplication designer may then preview the native mobile applications byclicking a web URL that may download and install the applications over awireless network on a supported mobile device, such as, but not limitedto, Android-based devices 720 and/or iOS-based devices 722. Both thecompiled native application and the source code may be available fordownload. The source code can be executed on any computer that has therequisite development tools installed to compile the source code anddisplay the app in a simulator or emulator. The compiled versions of thenative application may be installed on any device that has theappropriate certificates to run the application.

Referring again to FIG. 1, once the application designer is satisfiedwith the preview of their application 112, they may choose to publishthe application 114 for use by an end-user audience. A user may alsochoose to publish the application 114 for use by an end-user audiencewithout previewing. As illustrated in FIG. 3, the application designermay click a publish button within the user interface 310, which may bebrowser-based. This may initiate a publication process based on thecurrent application metadata definition 316. The platform may includemultiple generators 326 that may read the application definitionmetadata 316 and may automatically create new versions of the clientmobile applications 330 based on the changed metadata for each mobileoperating system and platform that are supported by each generator. Whenthe generator examines the metadata and generates a new application (SDKand UI), the version on the SDK and UI may be incremented. For example,there may be generators 326 for HTML5 web applications, Android nativeapplications, iOS native applications, and/or other applications. A newversion of the run-time service application 332 may be generated by theplatform based on the metadata definition 316, which may providesupporting functions to the client applications 330 such as, but notlimited to, user authentication, role based access, business logic,and/or extension functionality 324. The run-time service application 332may be a self-contained server-side application that may be furthercustomized by application designers as needed. Customizations to theserver-side application can be made by writing custom code on theapplication objects' model or controller areas, or by editing thegenerated source code of the server-side application outside theplatform. Further, as illustrated in FIG. 8, the run-time serverapplication may be deployed to a network and/or system operator managedservers 814 and/or to servers managed by operator customers or partners820 via a third-party source code repository 818 that may also manageany optional customizations made by customers or partners to therun-time service application code.

Referring again to FIG. 3, the platform may provide support forauthorized third-party applications 311 to connect to the design-timeservices application programming interface (API) 312 via login to anappropriate account within the multi-tenant design-time environment 314,and may programmatically create or update application definitionmetadata 316 and may initiate the preview or publishing 328 of a mobileapplication based on the metadata. For example, this may happen when theplatform serves as a mobile application generator for a third partyapplication such as an enterprise resource planning (ERP) solutiondeveloped by a third party software vendor. In this example, if the ERPsoftware vendor wants to provide its customers with the ability togenerate customized mobile apps that are integrated directly to the ERPsolution, the vendor may allow their users to select from a series ofoptions such as which ERP objects and fields to mobile-enable, and thenemploy the platform design-time services API to programmatically createnew application metadata, possibly via the selection of a template,comprising data sources 317, objects 318, user interface components 320,and/or extensions 322. The ERP system can then use the design-timeservices API to generate the application and provide the user with alink to download and run the generated mobile application. Further,authorized third party applications 334 may also connect to the run-timeservices API 332 and may programmatically access the same functions andoperations available to the mobile client applications 330. This methodmay be used, for example, to facilitate integration with third partyapplications such as a corporate intranet or human resources (HR)application. For example, an employee services mobile app may be used byemployees to submit recognition to colleagues in appreciation of a taskwell done. The corporate intranet application may provide a screencalled “Top Employees of the Month” and may connect to the run-timeservices API to obtain a count of all recognition records across allemployees for a given month via the recognition object. The applicationmay then present the intranet user with the top ten employees ranked byrecognition count. During the annual review process, the HR applicationcan connect to the run-time services API to obtain a count of allrecognition records for a given employee for the year via therecognition object. The application may then present the manager userwith the recognition information to be used in the review process. Thiscapability to provide third-party applications, with both a design-timeservices API to programmatically define an application and a run-timeservices API to programmatically interface with a generated application,may be enabled by strict architectural separation between thedesign-time and run-time components of the platform. The design-timecomponents may include the multi-tenant account management layer 314,the application definition metadata 316, and/or the application (userinterface and software development kit) generators 326. The run-timecomponents may include the run-time services API 332, installedextensions 324, and/or client-side applications 330 (consisting of auser interface and software development kit), which may run as either anative app within a mobile operating system or a web app within a webbrowser.

The platform may enable application designers to assemble and deploymobile applications across multiple mobile operating systems andplatforms from a single application metadata definition edited within aweb-based graphical user interface. Further, the application may providemobile-enabled access to data, or subsets thereof, from multipledifferent data sources, and may include a granular user access system tocontrol permissions at the data field level. Further, the applicationfunctionality may be expanded by installing extensions or viaevent-triggered custom code. Further, the platform may obviate the needfor any installation of software development environments byautomatically compiling native applications on appropriate web-basedservers. Further, the platform may generate a self-contained run-timeapplication server that can be further customized by developers andhosted on server infrastructure chosen by the customer. Further, boththe design-time services and run-time services may be accessedprogrammatically by authorized third-party applications to facilitatedata integration or automated mobile application generation.

While various embodiments have been described above, it should beunderstood that they have been presented by way of example and notlimitation. It will be apparent to persons skilled in the relevantart(s) that various changes in form and detail can be made thereinwithout departing from the spirit and scope. In fact, after reading theabove description, it will be apparent to one skilled in the relevantart(s) how to implement alternative embodiments. Thus, the presentembodiments should not be limited by any of the above-describedembodiments

In addition, it should be understood that any figures which highlightthe functionality and advantages are presented for example purposesonly. The disclosed methodology and system are each sufficientlyflexible and configurable such that they may be utilized in ways otherthan that shown.

Although the term “at least one” may often be used in the specification,claims and drawings, the terms “a”, “an”, “the”, “said”, etc. alsosignify “at least one” or “the at least one” in the specification,claims and drawings.

Finally, it is the applicant's intent that only claims that include theexpress language “means for” or “step for” be interpreted under 35U.S.C. 112, paragraph 6. Claims that do not expressly include the phrase“means for” or “step for” are not to be interpreted under 35 U.S.C. 112,paragraph 6.

What is claimed is:
 1. A method comprising: receiving, with a designmodule running on a processor in communication with a database, datacomprising a design for an application definition from a remote computervia a network, the application definition describing a function of anapplication; creating, with a design-time interface of the designmodule, a data source for the application definition, the data sourcecomprising a definition of a location from which data can be retrievedby the application and/or to which data can be saved by the application;mapping, with the design-time interface of the design module, an objectto the data source; receiving, with the design module, a selection ofone or more client operating platforms for application publication fromamong a plurality of platforms from the remote computer via the network;generating, with at least one generator module, source code for theapplication including source code for a client application componentnative to each of the selected one or more client operating platformsusing the application definition; and sending, with the design module,the source code for the application to the remote computer.
 2. Themethod of claim 1, further comprising: sending to the remote computervia the network, with the processor, data enabling a display associatedwith the remote computer to display template information associated witha template; and wherein the receiving of the data comprising the designfor the application definition comprises receiving data placed in thetemplate.
 3. The method of claim 1, further comprising storing, with theprocessor, the application definition in the database.
 4. The method ofclaim 3, further comprising: retrieving, with the processor, the storedapplication definition from the database; receiving, with the processor,data associated with a change to the retrieved application definition;and modifying, with the processor, the retrieved application definitionby incorporating the received data into the retrieved applicationdefinition.
 5. The method of claim 3, further comprising: generating,with the remote computer, the data associated with the change to theretrieved application definition; and sending, with the remote computer,the data associated with the change to the retrieved applicationdefinition to the processor via the network.
 6. The method of claim 1,further comprising storing the source code for the application in thedatabase.
 7. The method of claim 1, further comprising: generating, withthe at least one generator module, a preview application for each of theselected one or more client operating platforms from the applicationdefinition; and sending to the remote computer via the network dataenabling a display associated with the remote computer to display thepreview application.
 8. The method of claim 1, further comprising:receiving, with the processor, data associated with a third-partyapplication; integrating, with the processor, the data associated withthe third-party application into the application definition.
 9. Themethod of claim 1, wherein the generating of the source code for theapplication comprises installing an extension, generating custom logic,and/or assembling a user interface.
 10. The method of claim 1, whereinthe generating of the application comprises generating libraries. 11.The method of claim 1, wherein the location defined by the data sourcecomprises a database, a web service, and/or a software application. 12.The method of claim 1, wherein the generating of the source code for theapplication comprises: incorporating pre-built code into the source codefor the application; receiving custom code from the remote computer andincorporating the custom code into the source code for the application;or a combination thereof.
 13. The method of claim 1, further comprising:generating, with the remote computer, the data comprising the design forthe application definition; and sending, with the remote computer, thedata comprising the design for the application definition to theprocessor via the network.
 14. The method of claim 1, further comprisingcompiling, with the least one generator module, the source code for theapplication to generate the application.
 15. The method of claim 14,further comprising sending, with the design module, the application tothe remote computer.
 16. The method of claim 14, further comprisingstoring the application in the database.
 17. The method of claim 1,wherein the generated source code is uncompiled source code.
 18. Themethod of claim 1, wherein the generated source code includes sourcecode for a run-time services component employed by all of the selectedone or more client operating platforms.
 19. The method of claim 18,wherein: the client application component is configured to be executedby a client; and the run-time services component is configured to beexecuted by a server in communication with the client.
 20. The method ofclaim 1, wherein the application for each of the selected one or moreclient operating platforms is independent of the design module.
 21. Asystem comprising: a database; a processor in communication with thedatabase, the processor constructed and arranged to: receive datacomprising a design for an application definition from a remote computervia a network, the application definition describing a function of anapplication; create, with a design-time interface, a data source for theapplication definition, the data source comprising a definition of alocation from which data can be retrieved by the application and/or towhich data can be saved by the application; map, with the design-timeinterface, an object to the data source; generate, with the design-timeinterface, an application definition from the data source and object;and receive a selection of one or more client operating platforms forapplication publication from among a plurality of platforms from theremote computer via the network; and at least one generator module,running on the processor or another processor constructed and arrangedto generate source code for the application including source code for aclient application component native to each of the selected one or moreclient operating platforms using the application definition; wherein theprocessor is further constructed and arranged to send the source codefor the application to the remote computer.
 22. The system of claim 21,wherein: the processor is further constructed and arranged to send, tothe remote computer via the network, data enabling a display associatedwith the remote computer to display template information associated witha template; and wherein the processor receives data placed in thetemplate.
 23. The system of claim 21, wherein the processor is furtherconstructed and arranged to store the application definition in thedatabase.
 24. The system of claim 20, wherein the processor is furtherconstructed and arranged to: retrieve the stored application definitionfrom the database; receive data associated with a change to theretrieved application definition; and modify the retrieved applicationdefinition by incorporating the received data into the retrievedapplication definition.
 25. The system of claim 20, wherein the remotecomputer is constructed and arranged to: generate the data associatedwith the change to the retrieved application definition; and send thedata associated with the change to the retrieved application definitionto the processor via the network.
 26. The system of claim 21, whereinthe at least one generator module is further constructed and arranged tostore the source code for the application in the database.
 27. Thesystem of claim 21, wherein the at least one generator module is furtherconstructed and arranged to: generate a preview application for each ofthe selected one or more client operating platforms from the applicationdefinition; and send, to the remote computer via the network, dataenabling a display associated with the remote computer to display thepreview application.
 28. The system of claim 21, wherein the processoris further constructed and arranged to: receive data associated with athird-party application; integrate the data associated with thethird-party application into the application design.
 29. The system ofclaim 21, wherein the at least one generator module installs anextension, generates custom logic, and/or assembles a user interface.30. The system of claim 21, wherein the generating of the applicationcomprises generating libraries.
 31. The system of claim 21, wherein thelocation defined by the data source comprises a database, a web service,and/or a software application.
 32. The system of claim 21, wherein thegenerating of the application comprises: incorporating pre-built codeinto the source code for the application; receiving custom code from theremote computer and incorporating the custom code into the source codefor the application; or a combination thereof.
 33. The system of claim21, wherein the remote computer is constructed and arranged to: generatethe data for the application definition; and send the data for theapplication definition to the processor via the network.
 34. The systemof claim 21, wherein the at least one generator module is furtherconstructed and arranged to compile the source code for the applicationto generate the application.
 35. The system of claim 34, wherein theprocessor is further constructed and arranged to send the application tothe remote computer.
 36. The system of claim 34, wherein the at leastone generator module is further constructed and arranged to store theapplication in the database.
 37. The system of claim 34, wherein thegenerated source code is uncompiled source code.
 38. The system of claim34, wherein the generated source code includes source code for arun-time services component employed by all of the selected one or moreclient operating platforms.
 39. The system of claim 38, wherein: theclient application component is configured to be executed by a client;and the run-time services component is configured to be executed by aserver in communication with the client.
 40. The system of claim 34,wherein the application for each of the selected one or more clientoperating platforms is independent of the design module.